/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.etrs.formathlon.vue.jsf.utils;

import java.util.ArrayList;
import java.util.List;
import net.etrs.formathlon.control.exception.ExceptionManager;
import net.etrs.formathlon.entity.utils.ComparableEvenThoughUnpersisted;
import net.etrs.formathlon.persistance.utils.AbstractFacade;

/**
 * Classe qui permet Create / Update / Delete sur une liste d'entités T.
 * @author OPIF
 */
public abstract class CUDBean
        <T extends ComparableEvenThoughUnpersisted, F extends AbstractFacade<T>>
        extends GeneralBean implements Confirmable {
    
    private T entite;
    private List<T> listEntite = new ArrayList<T>();
    
    private boolean modeCreation = true;
    
    /**
     * Initialisation du managed bean.
     */
    protected void init(){
        setEntite(getFacade().newInstance());
        setListEntite(getFacade().readAll());
    }
    
    /**
     * Demande de création de l'objet de type T.
     */
    public void creer(){
        getPopupBean().open(getMessage("application.CUDBean.creer"));
        modeCreation=true;
        entite = getFacade().newInstance();
    }
    
    /**
     * Demande de modification de l'objet de type T.
     * @param t 
     */
    public void modifier(T t){
        getPopupBean().open(getMessage("application.CUDBean.modifier"));
        modeCreation=false;
        entite = t;
    }
    
    /**
     * Suppression de l'objet de type T.
     * @param t 
     */
    public void supprimer(T t){
        entite = t;
        getConfirmationBean().open(this, getMessage("application.CUDBean.supprimer"));
    }
    
    /**
     * Annulation de la modification ou de la création
     * en réinitialisant le bean managé.
     */
    public void annuler() {
        init();
    }
    
    /**
     * Validation de la création de l'objet de type T.
     * @return true si l'opération s'est bien déroulée.
     */
    public boolean validerCreer(){
        try {
            getFacade().create(entite);
            listEntite.add(entite);
            displayMessage(getMessage("application.CUDBean.validerCreer"));
            return true;
        } catch (Exception ex) {
            displayErreur(ExceptionManager.traiter(ex));
            return false;
        }
    }
    
    /**
     * Validation de la modification de l'objet de type T.
     * @return true si l'opération s'est bien déroulée.
     */
    public boolean validerModifier(){
        try {
            getFacade().update(entite);
            displayMessage(getMessage("application.CUDBean.validerModifier"));
            return true;
        } catch (Exception ex) {
            displayErreur(ExceptionManager.traiter(ex));
            return false;
        }
    }
    
    /**
     * Validation de la suppression de l'objet entité.
     * @return true si l'opération s'est bien déroulée.
     */
    public boolean validerSuppression() {
        try {
            getFacade().delete(entite);
            listEntite.remove(entite);
            displayMessage(getMessage("application.CUDBean.validerSuppression"));
            return true;
        } catch (Exception ex) {
            displayErreur(ExceptionManager.traiter(ex));
            return false;
        }
    }

    @Override
    public void confirmer() {
        // il n'y a que la suppression qui peut être confirmée.
        validerSuppression();
    }
    @Override
    public void infirmer() {
        init();
    }
    
    /**
     * Permet à cette classe de récupérer la facade utilisée par la classe fille.
     * @return la facade concernant l'extension T
     */
    protected abstract F getFacade();

    /**
     * @return the entite
     */
    protected T getEntite() {
        return entite;
    }

    /**
     * @param entite the entite to set
     */
    protected void setEntite(T entite) {
        this.entite = entite;
    }

    /**
     * @return the listEntite
     */
    protected List<T> getListEntite() {
        return listEntite;
    }

    /**
     * @param listEntite the listEntite to set
     */
    protected void setListEntite(List<T> listEntite) {
        this.listEntite = listEntite;
    }

    /**
     * @return the modeCreation
     */
    public boolean isModeCreation() {
        return modeCreation;
    }

    /**
     * @param modeCreation the modeCreation to set
     */
    public void setModeCreation(boolean modeCreation) {
        this.modeCreation = modeCreation;
    }
    
}
